/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package screen;

import framework.Key;
import framework.Screen;
import framework.Util;
import game.Bomba;
import game.Global;
import game.Inimigo;
import game.Inimigo_;
import game.Item;
import game.Legiao;
import game.Nave;
import game.Tiro;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyEvent;
import java.sql.Time;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Timer;

/**
 *
 * @author edilson
 */
public class GameScreen extends Screen {

    private Image back;
    private int blockNumbers;
    private Nave nave;
    private List<Tiro> tiros;
    private List<Inimigo> inimigos;
    private List<Bomba> bombas;
    private List<Item> itens;
    //private List legioes;
    private long cont;
    private int y;
    private int speedY;
    private int navesExistentes;
    private int completo;
    private int go;
    private List<Legiao> legioes;
    private boolean paused;

    public GameScreen() {
        back = Util.loadImage(Global.IMG_GAME_BACK2);
        cont = 0;

        legioes = new ArrayList<Legiao>();

        navesExistentes = 0;

        nave = Global.naveAtiva;

        tiros = new ArrayList<Tiro>();
        inimigos = new ArrayList<Inimigo>();
        bombas = new ArrayList<Bomba>();
        itens = new ArrayList<Item>();

        speedY = 1;
        completo = 0;
        go = 0;

        //criarInimigos();
        Legiao legiao = Global.getFase();
        inimigos = legiao.criarNaves();
        navesExistentes = inimigos.size();

        paused = false;

    }

    @Override
    public void update() {

        // sair do jogo
        if (Key.isTyped(KeyEvent.VK_PAUSE)) {
            if (paused) {
                paused = false;
            } else {
                paused = true;
            }
        }


        if (!paused) {


            cont++;
            y += speedY;



            if (cont % 100 == 0) {
                clearList();
                updateTiro();
            }


            if (cont % 400 == 0) {
                updateTiro();
            }

            //atualiza os objetos da tela;
            nave.update();
            for (Tiro tiro : tiros) {
                tiro.update();
            }
            for (Inimigo inimigo : inimigos) {
                inimigo.update();
            }
            for (Bomba bomba : bombas) {
                bomba.update();
            }
            for (Item item : itens) {
                item.update();
            }



            // sair do jogo
            if (Key.isTyped(KeyEvent.VK_ESCAPE)) {
                Global.zerar();
                Screen.setCurrentScreen(new TitleScreen());
            }


            //itens
            if (cont % 400 == 0) {
                if (Util.random(1) == 0) {
                    itens.add(sortItem());
                }
            }
            for (Item item : itens) {
                if (item.getState() == Item.STATE_MOVING && nave.getState() == Nave.STATE_MOVING) {
                    if (nave.collidesWith(item)) {
                        capturaItem(item);
                    }
                }
            }

            // tiro
            if (Key.isTyped(KeyEvent.VK_SPACE) && nave.getState() == Nave.STATE_MOVING) {
                Tiro tiro;
                switch (nave.getTiro()) {
                    case 1:
                        if (isPossible()) {
                            tiro = new Tiro(0, nave.getY(), nave.getTipoTiro());
                            tiro.setX(nave.getX() + 25 - (tiro.getWidth() / 2));
                            tiros.add(tiro);
                        }
                        break;
                    case 2:
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 5, nave.getY(), nave.getTipoTiro()));
                        }
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 38, nave.getY(), nave.getTipoTiro()));
                        }
                        break;
                    case 3:
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 5, nave.getY(), nave.getTipoTiro()));
                        }
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 38, nave.getY(), nave.getTipoTiro()));
                        }
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 24, nave.getY(), nave.getTipoTiro()));
                        }
                        break;
                    case 4:
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 0, nave.getY(), nave.getTipoTiro()));
                        }
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 10, nave.getY(), nave.getTipoTiro()));
                        }
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 20, nave.getY(), nave.getTipoTiro()));
                        }
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 30, nave.getY(), nave.getTipoTiro()));
                        }

                        break;
                    case 5:
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 5, nave.getY(), nave.getTipoTiro()));
                        }
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 38, nave.getY(), nave.getTipoTiro()));
                        }
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 24, nave.getY(), nave.getTipoTiro()));
                        }
                        if (isPossible()) {
                            tiro = new Tiro(nave.getX() + (-5), nave.getY(), nave.getTipoTiro());
                            tiro.setSpeedX(-1);
                            tiros.add(tiro);
                        }
                        if (isPossible()) {
                            tiro = new Tiro(nave.getX() + 55, nave.getY(), nave.getTipoTiro());
                            tiro.setSpeedX(1);
                            tiros.add(tiro);
                        }

                        break;
                    case 6:
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 0, nave.getY(), nave.getTipoTiro()));
                        }
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 10, nave.getY(), nave.getTipoTiro()));
                        }
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 20, nave.getY(), nave.getTipoTiro()));
                        }
                        if (isPossible()) {
                            tiros.add(new Tiro(nave.getX() + 30, nave.getY(), nave.getTipoTiro()));
                        }
                        if (isPossible()) {

                            tiro = new Tiro(nave.getX() + (-5), nave.getY(), nave.getTipoTiro());
                            tiro.setSpeedX(-1);
                            tiros.add(tiro);
                        }
                        if (isPossible()) {
                            tiro = new Tiro(nave.getX() + 55, nave.getY(), nave.getTipoTiro());
                            tiro.setSpeedX(1);
                            tiros.add(tiro);
                        }
                        break;

                }
            }

//
//        //tipo de tiro
//        if (Key.isTyped(KeyEvent.VK_1)) {
//            Global.typeTiro = Tiro.TYPE_1;
//        } else if (Key.isTyped(KeyEvent.VK_2)) {
//            Global.typeTiro = Tiro.TYPE_2;
//        } else if (Key.isTyped(KeyEvent.VK_3)) {
//            Global.typeTiro = Tiro.TYPE_3;
//        } else if (Key.isTyped(KeyEvent.VK_4)) {
//            Global.typeTiro = Tiro.TYPE_4;
//        } else if (Key.isTyped(KeyEvent.VK_5)) {
//            Global.typeTiro = Tiro.TYPE_5;
//        } else if (Key.isTyped(KeyEvent.VK_6)) {
//            Global.typeTiro = Tiro.TYPE_6;
//        }

            //tiro inimigo
            for (Inimigo inimigo1 : inimigos) {
                if (inimigo1.isAtivo() && inimigo1.isVisible()) {
                    if (Util.random(inimigo1.getIndiceBombas()) == 1) {
                        bombas.add(new Bomba(inimigo1.getX(), inimigo1.getY()));
                    }
                }

            }

            //colisão naveXinimigo
            for (Inimigo inimigo : inimigos) {
                if (inimigo.isVisible() && inimigo.getState() == Inimigo.STATE_MOVING && nave.getState() == Nave.STATE_MOVING) {
                    nave.collidesWithAndDecrementPower(inimigo);//&& inimigo.getState()==Inimigo.STATE_MOVING
                    //                    inimigo.bomm();

                }
            }

            for (Bomba bomba : bombas) {
                if (nave.getState() == Nave.STATE_MOVING && bomba.getState() == Bomba.STATE_MOVING) {
                    if (nave.collidesWithAndDecrementPower(bomba)) {
                        //Global.lifes--;
                        //bomba.bomm();
                    }
                }
            }

            //colisão inimigo x tiro
            for (Inimigo inimigo : inimigos) {
                if (inimigo.isVisible() && inimigo.isAtivo()) {
                    for (Tiro tiro : tiros) {
                        if (tiro.isVisible() && tiro.getState() != Tiro.STATE_DEAD && tiro.getState() != Tiro.STATE_DYING) {
                            if (inimigo.collidesWithAndDecrementPower(tiro)) {
                                Global.pontuacao += Global.level * 10;
                                tiro.setPower(0);

                            }
                        }

                    }
                }
            }

            int numero = 0;

            //Level Completo
            for (Inimigo inimigo1 : inimigos) {
                if (inimigo1.isVisible()) {
                    numero++;
                }
            }
            if (numero <= 0) {
                completo++;
            }
            if (completo >= 300 && nave.getState() == Nave.STATE_MOVING) {
                Screen.setCurrentScreen(new GameLevelScreen());
            }

            if (nave.getPower() <= 0) {
                go++;

            }
            if (go >= 300) {
                Global.lifes--;
                if (Global.lifes <= 0) {
                    Screen.setCurrentScreen(new GameOverScreen());
                } else {
                    Screen.setCurrentScreen(new GameLevelScreen());
                }
            }
        }
    }

    private Item sortItem() {

        int typeItem = Item.TYPE_TIRO_1;

        int t1 = 10;
        int t2 = t1 + 9;
        int t3 = t2 + 8;
        int t4 = t3 + 7;
        int t5 = t4 + 6;
        int t6 = t5 + 5;
        int life = t6 + 10;

        int sort = Util.random(life);


        if (sort < t1) {
            typeItem = Item.TYPE_TIRO_1;
        } else if (sort < t2) {
            typeItem = Item.TYPE_TIRO_2;
        } else if (sort < t3) {
            typeItem = Item.TYPE_TIRO_3;
        } else if (sort < t4) {
            typeItem = Item.TYPE_TIRO_4;
        } else if (sort < t5) {
            typeItem = Item.TYPE_TIRO_5;
        } else if (sort < t6) {
            typeItem = Item.TYPE_TIRO_6;
        } else if (sort < life) {
            typeItem = Item.TYPE_LIFE;
        }

        System.out.println(sort);

        Item item = new Item(Util.random(Screen.getWidth() - 50) + 25, 0, typeItem);

        return item;
    }

    @Override
    public void paint(Graphics g) {

        //fundo
        g.drawImage(back, 0, y - back.getHeight(null), null);
        g.drawImage(back, back.getWidth(null), y - back.getHeight(null), null);
        g.drawImage(back, back.getWidth(null) * 2, y - back.getHeight(null), null);

        g.drawImage(back, 0, y, null);
        g.drawImage(back, back.getWidth(null), y, null);
        g.drawImage(back, back.getWidth(null) * 2, y, null);

        g.drawImage(back, 0, y + back.getHeight(null), null);
        g.drawImage(back, back.getWidth(null), y + back.getHeight(null), null);
        g.drawImage(back, back.getWidth(null) * 2, y + back.getHeight(null), null);

        if (y >= back.getHeight(null)) {
            y = 0;
        }



        //desenha objetos na tela

        for (Inimigo inimigo : inimigos) {
            inimigo.paint(g);
        }
        for (Tiro tiro : tiros) {
            tiro.paint(g);
        }
        for (Bomba bomba : bombas) {
            bomba.paint(g);
        }
        for (Item item : itens) {
            item.paint(g);
        }


        nave.paint(g);



        //PAINEL
        g.setColor(Color.yellow);
        g.drawRect(0, 0, Screen.getWidth(), 30);
        g.drawString("Level: " + Global.level, 10, 20);
        g.drawString("Pontuação: " + Global.pontuacao, 50, 20);
        g.drawString("Restando: " + this.navesExistentes + "/" + this.inimigos.size(), 250, 20);

        //g.drawImage(Util.loadImage(Global.IMG_TIRO_1), 300, 20, null);
        g.drawString("Tiro1: " + nave.getMunicao(Tiro.TYPE_1), 100, 40);
        g.drawString("Tiro2: " + nave.getMunicao(Tiro.TYPE_2), 200, 40);
        g.drawString("Tiro3: " + nave.getMunicao(Tiro.TYPE_3), 300, 40);
        g.drawString("Tiro4: " + nave.getMunicao(Tiro.TYPE_4), 400, 40);
        g.drawString("Tiro5: " + nave.getMunicao(Tiro.TYPE_5), 500, 40);
        g.drawString("Tiro6: " + nave.getMunicao(Tiro.TYPE_6), 600, 40);




        g.drawString("Energia: ", 550, 20);
        g.drawRect(600, 10, 100, 10);
        if (nave.getPower() > 25) {
            g.setColor(Color.GREEN);
        } else {
            g.setColor(Color.RED);
        }

        g.fillRect(600, 10, nave.getPower(), 10);

        g.setColor(Color.yellow);

        g.drawString("Vidas: " + Global.lifes, 750, 20);



    }

    private void clearList() {
        List<Inimigo> inimigoAux = new ArrayList();
        for (Inimigo inimigo : inimigos) {
            if (inimigo.isVisible()) {
                inimigoAux.add(inimigo);
            }
        }
        inimigos = inimigoAux;

        List<Tiro> tiroAux = new ArrayList();
        for (Tiro tiro : tiros) {
            if (tiro.isVisible()) {
                tiroAux.add(tiro);
            }
        }
        tiros = tiroAux;

        List<Bomba> bombasAux = new ArrayList<Bomba>();
        for (Bomba bomba : bombas) {
            if (bomba.isVisible()) {
                bombasAux.add(bomba);
            }
        }
        bombas = bombasAux;
    }

    private void capturaItem(Item item) {
        switch (item.getType()) {
            case Item.TYPE_TIRO_1:
//                nave.setTipoTiro(Tiro.TYPE_1);
                nave.addMunicao(Tiro.TYPE_1, 100);
                break;
            case Item.TYPE_TIRO_2:
//                nave.setTipoTiro(Tiro.TYPE_2);
                nave.addMunicao(Tiro.TYPE_2, 100);
                break;
            case Item.TYPE_TIRO_3:
//                nave.setTipoTiro(Tiro.TYPE_3);
                nave.addMunicao(Tiro.TYPE_3, 100);
                break;
            case Item.TYPE_TIRO_4:
//                nave.setTipoTiro(Tiro.TYPE_4);
                nave.addMunicao(Tiro.TYPE_4, 100);
                break;
            case Item.TYPE_TIRO_5:
//                nave.setTipoTiro(Tiro.TYPE_5);
                nave.addMunicao(Tiro.TYPE_5, 100);
                break;
            case Item.TYPE_TIRO_6:
//                nave.setTipoTiro(Tiro.TYPE_6);
                nave.addMunicao(Tiro.TYPE_6, 100);
                break;
            case Item.TYPE_LIFE:
                int power = nave.getPower();
                power += 25;
                if (power > 100) {
                    power = 100;
                }
                nave.setPower(power);
                break;
        }
//        if (nave.getTiro() > 6) {
//            nave.setTiro(6);
//        }
        item.setPower(0);
    }
    //verifica se possui munica
    //se nao possui, muda o tipo de tiro

    private boolean isPossible() {
        if (nave.getMunicao(nave.getTipoTiro()) > 0) {
            nave.addMunicao(nave.getTipoTiro(), -1);
            return true;
        } else {
            updateTiro();
            if (nave.getMunicao(nave.getTipoTiro()) > 0) {
                nave.addMunicao(nave.getTipoTiro(), -1);
                return true;
            }
        }
        return false;



    }

    private void updateTiro() {
        for (int i = 1; i <= 6; i++) {
            System.out.println("Atual: " + nave.getMunicao(nave.getTipoTiro()) + " - tipo" + i + ": " + nave.getMunicao(i));
            if (nave.getMunicao(i) > nave.getMunicao(nave.getTipoTiro())) {
                System.out.println("troca para tipo " + i);
                nave.setTipoTiro(i);
            }
        }
    }
}
